/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package Interface;

import java.awt.Graphics;
import java.awt.Polygon;
import moteur.carte.Chemin;

/**
 * Contient des fonction utilitaires. Final pour aider le compilateur just in time à inliner si necessaire.
 * @author Administrateur
 */
public class util {

    /**
     * Renvoie la valeur projeté depuis [x1 , x2] dans [y1 , y2]
     * @param value
     * @param x1
     * @param x2
     * @param y1
     * @param y2
     * @return
     */
    public static final float mapf(float value, float x1, float x2, float y1, float y2){
        //if (x1 == x2) return java.lang.Float.NaN; // commentaire pour optimiser les performances.
        return  y1 + (y1 - y2) * (value - x1) / (x1 - x2) ;
    }

    /**
     * Contraind une valeur a un interval. Utile pour empecher un objet de sortir de l'écran par exemple.
     * A noter que map ne contraind pas.
     * @param a
     * @param borne1
     * @param borne2
     * @return
     */
    public static final float constrain(float a, float borne1, float borne2){
    if(borne1 > borne2){float tmp = borne1; borne2 = borne1; borne1 = tmp;}
    if (a<borne1) return borne1;
    if (a>borne2) return borne2;
    return a;
    }


    /**
     * Un modulo sur les float qui ne renvoie qu'un résultat positif. Math.IEEEremainder() pour un "vrai" modulo matheux.
     * @param a
     * @param b
     * @return a modulo b.
     */
    public static final float modulo(float a, float b){
        return a - b * (int)(a/b);
    }

    /**
     * 
     * @param a
     * @param b
     * @param c
     * @param d
     * @return
     */
    public static boolean collision(float a, float b, float c, float d){
        return (c < b && c> a) || (d < b && d > a) ;
    }

    /**
     *
     * @param a
     * @param b
     * @param c
     * @param d
     * @return
     */
    public static boolean NONcollision(float a, float b, float c, float d){
        return c > b || d < a || (d > b && c < a) ;
    }

public static void drawChemin(Graphics g, int x1, int y1, int x2, int y2, int largeur){
        int l = largeur/2;
        g.fillOval(x1-l, y1-l, largeur, largeur);
        g.fillOval(x2-l, y2-l, largeur, largeur);

        float m, p, norm;
        m = - (y1 - y2) / (float)(x1 - x2);
        p = 1;
        norm = (float)Math.sqrt(m*m + 1);

        m = m/norm*l; // pour eviter la déclaration de deux variable ml = m*l et pl = p*l supplémentaire.
        p = p/norm*l;

        Polygon pol = new Polygon();
        pol.addPoint(Math.round(x1 + m), Math.round(y1 + p));
        pol.addPoint(Math.round(x1 - m), Math.round(y1 - p));
        pol.addPoint(Math.round(x2 - m), Math.round(y2 - p));
        pol.addPoint(Math.round(x2 + m), Math.round(y2 + p));

        g.fillPolygon(pol);
    }

}
